#include "OgreStableHeaders.h"
#include "OgreCompositionPass.h"
#include "OgreMaterialManager.h"

namespace Ogre
{
	CompositionPass::CompositionPass(CompositionTargetPass* parent) :
		mParent(parent),
		mType(PT_RENDERQUAD),
		mIdentifier(0),
		mFirstRenderQueue(RENDER_QUEUE_BACKGROUND),
		mLastRenderQueue(RENDER_QUEUE_SKIES_LATE),
		mMaterialScheme(StringUtil::BLANK),
		mClearBuffers(FBT_COLOUR | FBT_DEPTH),
		mClearColour(0.0, 0.0, 0.0, 0.0),
		mClearDepth(1.0f),
		mClearStencil(0),
		mStencilCheck(false),
		mStencilFunc(CMPF_ALWAYS_PASS),
		mStencilRefValue(0),
		mStencilMask(0xFFFFFFFF),
		mStencilFailOp(SOP_KEEP),
		mStencilDepthFailOp(SOP_KEEP),
		mStencilPassOp(SOP_KEEP),
		mStencilTwoSidedOperation(false),
		mQuadCornerModified(false),
		mQuadLeft(-1),
		mQuadTop(1),
		mQuadRight(1),
		mQuadBottom(-1),
		mQuadFarCorners(false),
		mQuadFarCornersViewSpace(false)
	{
	}

	CompositionPass::~CompositionPass()
	{
	}

	void CompositionPass::setType(CompositionPass::PassType type)
	{

	}
	
	CompositionPass::PassType CompositionPass::getType() const
	{
		return mType;
	}
	
	void CompositionPass::setIdentifier(uint32 id)
	{
		mIdentifier = id;
	}
	
	uint32 CompositionPass::getIdentifier() const
	{
		return mIdentifier;
	}
	
	void CompositionPass::setMaterial(const MaterialPtr& mat)
	{
		mMaterial = mat;
	}
	
	void CompositionPass::setMaterialName(const String& name)
	{
		mMaterial = MaterialManager::getSingleton().getByName(name);
	}
	
	const MaterialPtr& CompositionPass::getMaterial() const
	{
		return mMaterial;
	}
	
	void CompositionPass::setClearBuffers(uint32 val)
	{
		mClearBuffers = val;
	}
	
	uint32 CompositionPass::getClearBuffers() const
	{
		return mClearBuffers;
	}
	
	void CompositionPass::setClearColour(ColourValue val)
	{
		mClearColour = val;
	}
	
	const ColourValue& CompositionPass::getClearColour() const
	{
		return mClearColour;
	}
	
	void CompositionPass::setInput(size_t id, const String& input, size_t mrtIndex)
	{
		assert(id < OGRE_MAX_TEXTURE_LAYERS);
		mInputs[id] = InputTex(input, mrtIndex);
	}
	
	const CompositionPass::InputTex& CompositionPass::getInput(size_t id) const
	{
		assert(id < OGRE_MAX_TEXTURE_LAYERS);
		return mInputs[id];
	}
	
	size_t CompositionPass::getNumInputs() const
	{
		size_t count = 0;
		for (size_t x = 0; x < OGRE_MAX_TEXTURE_LAYERS; ++x)
		{
			if (!mInputs[x].name.empty())
				count = x + 1;
		}
		return count;
	}
	
	void CompositionPass::clearAllInputs()
	{
		for (size_t x = 0; x < OGRE_MAX_TEXTURE_LAYERS; ++x)
		{
			mInputs[x].name.clear();
		}
	}
	
	CompositionTargetPass* CompositionPass::getParent()
	{
		return mParent;
	}
	
	void CompositionPass::setFirstRenderQueue(uint8 id)
	{
		mFirstRenderQueue = id;
	}
	
	uint8 CompositionPass::getFirstRenderQueue() const
	{
		return mFirstRenderQueue;
	}
	
	void CompositionPass::setLastRenderQueue(uint8 id)
	{
		mLastRenderQueue = id;
	}
	
	void CompositionPass::setMaterialScheme(const String& schemeName)
	{
		mMaterialScheme = schemeName;
	}
	
	const String& CompositionPass::getMaterialScheme(void) const
	{
		return mMaterialScheme;
	}
	
	uint8 CompositionPass::getLastRenderQueue() const
	{
		return mLastRenderQueue;
	}
	
	void CompositionPass::setClearDepth(Real depth)
	{
		mClearDepth = depth;
	}

	Real CompositionPass::getClearDepth() const
	{
		return mClearDepth;
	}

	void CompositionPass::setClearStencil(uint32 value)
	{
		mClearStencil = value;
	}

	uint32 CompositionPass::getClearStencil() const
	{
		return mClearStencil;
	}

	void CompositionPass::setStencilCheck(bool value)
	{
		mStencilCheck = value;
	}
	
	bool CompositionPass::getStencilCheck() const
	{
		return mStencilCheck;
	}
	
	void CompositionPass::setStencilFunc(CompareFunction value)
	{
		mStencilFunc = value;
	}
	
	CompareFunction CompositionPass::getStencilFunc() const
	{
		return mStencilFunc;
	}
	
	void CompositionPass::setStencilRefValue(uint32 value)
	{
		mStencilRefValue = value;
	}
	
	uint32 CompositionPass::getStencilRefValue() const
	{
		return mStencilRefValue;
	}
	
	void CompositionPass::setStencilMask(uint32 value)
	{
		mStencilMask = value;
	}
	
	uint32 CompositionPass::getStencilMask() const
	{
		return mStencilMask;
	}
	
	void CompositionPass::setStencilFailOp(StencilOperation value)
	{
		mStencilFailOp = value;
	}
	
	StencilOperation CompositionPass::getStencilFailOp() const
	{
		return mStencilFailOp;
	}
	
	void CompositionPass::setStencilDepthFailOp(StencilOperation value)
	{
		mStencilDepthFailOp = value;
	}
	
	StencilOperation CompositionPass::getStencilDepthFailOp() const
	{
		return mStencilDepthFailOp;
	}
	
	void CompositionPass::setStencilPassOp(StencilOperation value)
	{
		mStencilPassOp = value;
	}
	
	StencilOperation CompositionPass::getStencilPassOp() const
	{
		return mStencilPassOp;
	}
	
	void CompositionPass::setStencilTwoSidedOperation(bool value)
	{
		mStencilTwoSidedOperation = value;
	}
	
	bool CompositionPass::getStencilTwoSidedOperation() const
	{
		return mStencilTwoSidedOperation;
	}
	
	void CompositionPass::setQuadCorners(Real left, Real top, Real right, Real bottom)
	{
		mQuadCornerModified = true;
		
	}
}
